
#include "Public.h"


//1.  将uart2_1ms();函数插入到1ms中断里面
//2.  在主程序中引用     UART2_LINK(); 
//3.  在数据初始后插入
/*
//======================uart2================================
  
  uart2.err_delay_time=200;
  uart2.Tx_gap_time=20;  //发送完上个数据包后间隔20ms期间也没有接受到通信数据

  uart2.Tx_gap_cnt=0;
  uart2.gap_time_F=0; 
  
  uart2.err_delay_cnt=0;      
  uart2.err_delay_F=0; 

  USART2_Init();  //数据初始后才有波特率值

//======================uart2 end================================
*/
//4.  拷贝init_UART2_CONFIG.C  UART_DRV.C 到工程

//5.  在public.h中声明UART2结构体  
//    extern UART2_STRUCT  uart2;
//6.  在波特率会更改的情况下需要在程序中插入定时刷新波特率 void setup_uart2_BaudRate( void );//刷新波特率

//extern  u16 u32RTU_A_REG[30];
//extern  u16 u16RTU_B_REG[30]; 
//extern  u32 u32RTU_C_REG[30];//运行参数需要存储的
//extern  u16 u16RTU_D_REG[30]; 
//extern  u32 u32RTU_E_REG[20];//变量类开机重新初始化












UART2_STRUCT  uart2;//启用UART2结构体


void UART2Receive_res( void )//接收错误复位
{
  u16 i;
    uart2.Rxindex=0;     //复位接收指针
    for(i=0;i<USART2_REC_LEN;i++)//清零多少个字节
    {
      uart2.RxBuffer[i]=0;
    }
//    uart2.RxBufferSize=USART2_REC_LEN;

}



/*串口中断服务程序*/
void USART2_IRQHandler(void)
{
//static 
  
//  u16 i;
//  u16 crc_tempdata;  
  
  


//中断状态项  
//	USART_IT_WU：唤醒中断，STM32F030设备不可用。
//	USART_IT_CM:字符匹配中断。
//	USART_IT_EOB:块结束中断，不适用于STM32F030设备。
//	USART_IT_RTO：接收超时中断。
//	USART_IT_CTS：CTS更改中断。
//	USART_IT_LBD:LIN中断检测中断，不适用于STM32F030设备。
//	USART_IT_TXE:Tansmit数据寄存器空中断。
//	USART_IT_TC：传输完全中断。
//	USART_IT_RXNE：接收数据寄存器非空中断。
//	USART_IT_IDLE：空闲线路检测中断。
//	USART_IT_ORE:过度运行错误中断。
//	USART_IT_NE：噪声错误中断。
//	USART_IT_FE：帧错误中断。
//	USART_IT_PE：奇偶校验错误中断。
  
//中断使能项    
//	USART_IT_WU：唤醒中断，不适用于STM32F030设备。
//	USART_IT_CM：字符匹配中断
//	USART_IT_EOB:块结束中断，不适用于STM32F030设备。
//	USART_IT_RTO：接收超时中断。
//	USART_IT_CTS：CTS更改中断。
//	USART_IT_LBD:LIN中断检测中断，不适用于STM32F030设备。
//	USART_IT_TXE:Tansmit数据寄存器空中断。
//	USART_IT_TC：传输完全中断。
//	USART_IT_RXNE：接收数据寄存器非空中断。
//	USART_IT_IDLE：空闲线路检测中断。
//	USART_IT_PE：奇偶校验错误中断。
//	USART_IT_ERR：错误中断（帧错误、噪声错误、溢出错误）

//中断标志项    
//	USART_FLAG_ACK：接收启用确认标志。
//	USART_FLAG_EACK：传输启用确认标志。
//	USART_FLAG_WU：唤醒标志，不适用于STM32F030设备。
//	USART_FLAG_RWU：接收唤醒标志，不适用于STM32F030设备。
//	USART_FLAG_SBK:发送中断标志。
//	USART_FLAG_CM：字符匹配标志。
//	USART_FLAG_BUSY：忙标志。
//	USART_FLAG_ABRF：自动波特率标志。
//	USART_FLAG_ABRE：自动波特率错误标志。
//	USART_FLAG_EOB:块结束标志，不适用于STM32F030设备。
//	USART_FLAG_RTO：接收超时标志。
//	USART_FLAG_nCTSS：反相nCTS输入位状态。
//	USART_FLAG_CTS：CTS更改标志。
//	USART_FLAG_LBD:LIN断线检测标志，不适用于STM32F030设备。
//	USART_FLAG_TXE:传输数据寄存器空标志。
//	USART_FLAG_TC：传输完成标志。
//	USART_FLAG_RXNE：接收数据寄存器非空标志。
//	USART_FLAG_IDLE：空闲线路检测标志。
//	USART_FLAG_ORE：过度运行错误标志。
//	USART_FLAG_NE：噪声错误标志。
//	USART_FLAG_FE:Fr
  

  
  /*接收中断*/  
  if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
  {   
    /* Read one byte from the receive data register */


    uart2.Tx_gap_cnt=0;  //接收到数据就清零，间隔时间从没收到信息开始计时
    uart2.gap_time_F=0;    
    uart2.err_delay_cnt=0;//在接受数据时就清零     
    uart2.err_delay_F=0; 

      
    if(uart2.Rxindex<USART2_REC_LEN)//读数据
    {
      uart2.RxBuffer[uart2.Rxindex] = USART_ReceiveData(USART2);//读uart2数据      
    }
    else
    {
      uart2.Rxindex=USART2_REC_LEN;
    }
    uart2.Rxindex++;
    


    USART_ClearFlag(USART2,USART_FLAG_RXNE); //一定要清除接收中断 
  }  


  
  /*发送中断*/
  else if(USART_GetITStatus(USART2, USART_IT_TXE) != RESET)
  {  
//------------------------------------------------    
    uart2.Tx_gap_cnt=0;  //发送数据时将发送数据的间隔时间清零
    uart2.gap_time_F=0;
    uart2.err_delay_cnt=0;//在接受数据时就清零     
    uart2.err_delay_F=0;
    
    uart2.Txing_status=1;//是否已经发送完0发完1正在发
    

//---------------------------------------------
    

    if(uart2.Txindex >= uart2.TxBufferSize)//发送数据完成
    {   
      USART_ITConfig(USART2, USART_IT_TXE, DISABLE); //关闭发送中断
      USART_ITConfig(USART2, USART_IT_TC, ENABLE);  //打开传输完全中断。
      
      

      uart2.Txindex=0;
      
//      pc_plc_data.cmd_status=2;
    }
    else   
    {
      USART_SendData(USART2, uart2.TxBuffer[uart2.Txindex]);  
      uart2.Txindex++;  
    }

//    USART_ClearFlag(USART2,USART_IT_TXE); //一定要清除发送中断标志 
  } 
  
 
  /*发送完中断*/  
//---------------当发送最后一个数据完成后打开读使能-------------------   
  else if( USART_GetITStatus(USART2, USART_IT_TC) != RESET ) 
  {
    USART_ITConfig(USART2, USART_IT_TC, DISABLE);  //关闭传输完全中断。
    
    USART_ReceiveData(USART2);   //读一次数据
    
    uart2.Txing_status=0;//是否已经发送完0发完1正在发    
  }


  
  /*接收溢出中断*/
  
  else
  {
     USART_ClearFlag(USART2,USART_FLAG_ORE);//帧错误标志       

     USART_ClearFlag(USART2,USART_FLAG_CM);//字符匹配标志
     USART_ClearFlag(USART2,USART_FLAG_RTO);//接收超时标志
     USART_ClearFlag(USART2,USART_FLAG_CTS);//CTS更改标志
     USART_ClearFlag(USART2,USART_FLAG_TC);//传输完成标志
     
     
//     USART_ClearFlag(USART2,USART_FLAG_IDLE);//检测到IDLE行标志
     
//     USART_ClearFlag(USART2,USART_FLAG_NE);//噪声错误标志
//     USART_ClearFlag(USART2,USART_FLAG_FE);//帧错误标志
//     USART_ClearFlag(USART2,USART_FLAG_PE);//奇偶校验错误标志
     
//     USART_ClearFlag(USART2,USART_FLAG_SBK);//奇偶校验错误标志 
//     USART_ClearFlag(USART2,USART_FLAG_BUSY);//噪声错误标志
//     USART_ClearFlag(USART2,USART_FLAG_ABRF);//帧错误标志
//     USART_ClearFlag(USART2,USART_FLAG_ABRE);//奇偶校验错误标志  
//     USART_ClearFlag(USART2,USART_FLAG_nCTSS);//噪声错误标志

    
     
     
     
     
     
     USART_ReceiveData(USART2);   //读一次数据
  }

}

//	USART_FLAG_ACK ：接收启用确认标志。
//	USART_FLAG_EACK ：传输启用确认标志。
//	USART_FLAG_SBK :发送中断标志。

//	USART_FLAG_BUSY ：忙标志。
//	USART_FLAG_ABRF ：自动波特率标志。
//	USART_FLAG_ABRE ：自动波特率错误标志。

//	USART_FLAG_nCTSS ：反相nCTS输入位状态。
//	USART_FLAG_ORE ：过度运行错误标志。


void USART2_modbus_ONOFF(void);// modbus退出计数器 在程序里限制在1min退出
void USART2_modbus_ONOFF(void)// modbus退出计数器 在程序里限制在1min退出
{
  if(MODBUS_internet_EN!=0 && modbus_exit_cnt>=60)//60s退出
  {
    MODBUS_internet_EN=0;
    modbus_exit_cnt=0;
  }
}


void UART2Receive( void )//整理数据，判断数据包是否正确
{
  u16 i;
  u16 crc_tempdata;  
 
  data_485_Y_N=0; 
    if(MODBUS_internet_EN==1)
    {
      if(uart2.RxBuffer[1]==0x03 )//读数据
      {
        //
          
          uart2.RxBufferSize=uart2.RxBuffer[5]*2+6;

          data_485_Y_N=1; 
      }   

      else if(uart2.RxBuffer[1]==0x04)//读数据
      {
        //
          uart2.RxBufferSize=uart2.RxBuffer[5]*2+6;
          data_485_Y_N=1; 
      } 
      
      else if(uart2.RxBuffer[1]==0x06)//读数据
      {
        //

          uart2.RxBufferSize=8;
          data_485_Y_N=1; 
      }  

      else if(uart2.RxBuffer[1]==0x10)//读数据
      {
          uart2.RxBufferSize=uart2.RxBuffer[6]+9;
          data_485_Y_N=1; 
      } 
    }


    if ( uart2.RxBuffer[0]==0x7b   )    //"{"是不是json文件
    {
      data_485_Y_N=2; 
    }    


//===============处理==========================
    
    if(data_485_Y_N==1)  //485数据
    {
      if(uart2.RxBufferSize>=USART2_REC_LEN)//接收到额定长度的数据
      {
        uart2.RxBufferSize=USART2_REC_LEN;//防止后面crc计算错误      
      }

      for(i=0;i<uart2.RxBufferSize;i++)//转存接收到的数据
      {
        uart2.Rxdate[i]=uart2.RxBuffer[i] ;     
      }

      crc_tempdata=calculate_crc16(uart2.Rxdate,uart2.RxBufferSize-2,0xffff,0XA001);
      if((u8)crc_tempdata==uart2.Rxdate[uart2.RxBufferSize-2])
      {
        crc_tempdata=crc_tempdata>>8;
        if((u8)crc_tempdata==uart2.Rxdate[uart2.RxBufferSize-1])
        {
          uart2.RxCounterdata_filish=1;//读到完整数据
        }
        else
        {
          uart2.RxCounterdata_filish=0;//数据校验错误          
        }          
      }
      else
      {
        uart2.RxCounterdata_filish=0;//数据校验错误          
      } 
      
      UART2Receive_res();//复位接收状态    
    }
    else if(data_485_Y_N==2)  //json数据
    {  
      for(i=0;i<USART2_REC_LEN;i++)//转存接收到的数据
      {
        jsonBuffer_get[i]=uart2.RxBuffer[i] ;     
      }  
      
      uart2.RxCounterdata_filish=1;//读到完整数据

      UART2Receive_res();//复位接收状态         
    }
    else
    {  
      uart2.RxCounterdata_filish=0;//数据校验错误         
      UART2Receive_res();//复位接收状态        
    }      

}


void uart2_adress_error( u8 e_numble );//返回地址错误，1地址错误2初始地址加数据长度超范围

void uart2_adress_error( u8 e_numble )//返回地址错误，1地址错误2初始地址加数据长度超范围
{
    u16 crc_tempdata;  
    
    if(e_numble!=0)
    {
      uart2.TxBuffer[0]=uart2.Rxdate[0];
      uart2.TxBuffer[1]=uart2.Rxdate[1];
      uart2.TxBuffer[2]=69;//E
      uart2.TxBuffer[3]=82;//R              
      uart2.TxBuffer[4]=82;//R               
      uart2.TxBuffer[5]=e_numble;//1地址错误2初始地址加数据长度超范围
      crc_tempdata=calculate_crc16(uart2.TxBuffer,6,0xffff,0XA001);
      uart2.TxBuffer[6]=(u8)crc_tempdata;
      uart2.TxBuffer[7]=(u8)(crc_tempdata>>8);                
      
      uart2.Tx1_enable=1;                 
      uart2.Tx_standard=0;      //要发送的数据是否为标志协议，0 485数据,1json数据  
    }   
}




void UART2Handler( void );//整理数据

void UART2Handler( void )//整理数据
{


  
//u8 *cmd_ptr;//命令指针变量 
 u16 i;
 u16 temp;
//  u8 data_LEN;//有效数据长度
  u16 crc_tempdata;  
  
  u8 uart2_ERR_n;//错误码

  uart2_ERR_n=0;//错误码
      
//----------------------------------     
  
  if(uart2.RxCounterdata_filish==1 )//接收到数据需要处理
  {
    uart2.RxCounterdata_filish=0;
    
    if(data_485_Y_N==1   &&  uart2.Rxdate[0] == (u8)id_485)//485数据
    {
      if(MODBUS_internet_EN!=0 )//在485开启期间，接受到485信息就清零延时计数器，直到设定的时间内都没有接受到正确485信号就复位
      {
        modbus_exit_cnt=0;
      }
      
//      gc.WriteData_delay_cnt=0;
      gc.WriteData_filish =0;
      
      switch( uart2.Rxdate[1] )                        //
      {   
    
        case 0x03:  //读输出
          {   

              uart2.TxBuffer[0]=id_485;
              uart2.TxBuffer[1]=0x03;
              uart2.TxBuffer[2]=uart2.Rxdate[5]*2; 

              if(uart2.Rxdate[2]==0x01)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;
                    
                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    uart2.TxBuffer[3+i*2]=u32RTU_A_REG[temp+i]>>8;
                    uart2.TxBuffer[3+i*2+1]=u32RTU_A_REG[temp+i];                
                  }                  
                }
                
              
              }
              
              else if(uart2.Rxdate[2]==0x03)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;
                    
                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    uart2.TxBuffer[3+i*2]=u32RTU_C_REG[temp+i]>>8;
                    uart2.TxBuffer[3+i*2+1]=u32RTU_C_REG[temp+i];                
                  }                   
                }                
              }  
              else 
              {                  
                uart2_ERR_n=1;//1地址错误;
              }

              crc_tempdata=calculate_crc16(uart2.TxBuffer,uart2.TxBuffer[2]+3,0xffff,0XA001);
              uart2.TxBuffer[uart2.TxBuffer[2]+3]=(u8)crc_tempdata;
              uart2.TxBuffer[uart2.TxBuffer[2]+3+1]=(u8)(crc_tempdata>>8);
              
              uart2.Tx1_enable=1;
              uart2.Tx_standard=0;      //要发送的数据是否为标志协议，0 485数据,1json数据  



              uart2_adress_error(uart2_ERR_n);//返回地址错误
            
              

            break;
          }
          
        case 0x04:      //读输入
          {

            uart2.TxBuffer[0]=id_485;
            uart2.TxBuffer[1]=0x04;
            uart2.TxBuffer[2]=0x02;//数据字节数 


              if(uart2.Rxdate[2]==0x02)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;
                    
                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    uart2.TxBuffer[3+i*2]=u16RTU_B_REG[temp+i]>>8;
                    uart2.TxBuffer[3+i*2+1]=u16RTU_B_REG[temp+i];                
                  }                   
                  
                }                
              } 
              
              else if(uart2.Rxdate[2]==0x04)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;
                    
                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    uart2.TxBuffer[3+i*2]=u16RTU_D_REG[temp+i]>>8;
                    uart2.TxBuffer[3+i*2+1]=u16RTU_D_REG[temp+i];                
                  }                 
                }                
               
              }
              else 
              {                  
                uart2_ERR_n=1;//1地址错误;
              }
              
              


              crc_tempdata=calculate_crc16(uart2.TxBuffer,uart2.TxBuffer[2]+3,0xffff,0XA001);
              uart2.TxBuffer[uart2.TxBuffer[2]+3]=(u8)crc_tempdata;
              uart2.TxBuffer[uart2.TxBuffer[2]+3+1]=(u8)(crc_tempdata>>8);
              
              uart2.Tx1_enable=1; 
              uart2.Tx_standard=0;      //要发送的数据是否为标志协议，0 485数据,1json数据  
              
              
              
              
              
            uart2_adress_error(uart2_ERR_n);//返回地址错误         
              
              
                  
            break;
          }
        case 0x06:      //写     
          {

              uart2.TxBuffer[0]=uart2.Rxdate[0];
              uart2.TxBuffer[1]=uart2.Rxdate[1];
              uart2.TxBuffer[2]=uart2.Rxdate[2];
              uart2.TxBuffer[3]=uart2.Rxdate[3];              
              uart2.TxBuffer[4]=uart2.Rxdate[4];               
              uart2.TxBuffer[5]=uart2.Rxdate[5];
              crc_tempdata=calculate_crc16(uart2.TxBuffer,6,0xffff,0XA001);
              uart2.TxBuffer[6]=(u8)crc_tempdata;
              uart2.TxBuffer[7]=(u8)(crc_tempdata>>8);                
              
              uart2.Tx1_enable=1; 
              uart2.Tx_standard=0;      //要发送的数据是否为标志协议，0 485数据,1json数据  
              
              
              
              if(uart2.Rxdate[2]==0x01)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;

                  u32RTU_A_REG[temp]=(u16)uart2.Rxdate[4]<<8;
                  u32RTU_A_REG[temp]+=uart2.Rxdate[5]; 
                }
              }
              
              else if(uart2.Rxdate[2]==0x03)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;

                  u32RTU_C_REG[temp]=(u16)uart2.Rxdate[4]<<8;
                  u32RTU_C_REG[temp]+=uart2.Rxdate[5]; 
                }               
              } 
              else  //地址错误              
              {
                uart2_ERR_n=1;
              }              
              
              
              uart2_adress_error(uart2_ERR_n);//返回地址错误    

            break;
          }          
        case 0x10:      //写 
          {
//=======================默认回复==========================             
              uart2.TxBuffer[0]=uart2.Rxdate[0];
              uart2.TxBuffer[1]=uart2.Rxdate[1];
              uart2.TxBuffer[2]=uart2.Rxdate[2];
              uart2.TxBuffer[3]=uart2.Rxdate[3];              
              uart2.TxBuffer[4]=uart2.Rxdate[4];               
              uart2.TxBuffer[5]=uart2.Rxdate[5];
              
              crc_tempdata=calculate_crc16(uart2.TxBuffer,6,0xffff,0XA001);
              uart2.TxBuffer[6]=(u8)crc_tempdata;
              uart2.TxBuffer[7]=(u8)(crc_tempdata>>8);              
             
              uart2.Tx1_enable=1; 
              uart2.Tx_standard=0;      //要发送的数据是否为标志协议，0 485数据,1json数据  
              
              
              
//=======================根据指令改写数据==========================                     
              
              if(uart2.Rxdate[2]==0x01)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误2初始地址加数据长度超范围
                }
                else if(uart2.Rxdate[3]+uart2.Rxdate[5]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=2;//1地址错误2初始地址加数据长度超范围
                }
                else
                {
                  temp=uart2.Rxdate[3]-0x00;

                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    u32RTU_A_REG[temp+i]=(u16)uart2.Rxdate[7+i*2]<<8;
                    u32RTU_A_REG[temp+i]+=(u16)uart2.Rxdate[7+i*2+1];
                    
                  }                    

                }
              }
              
              else if(uart2.Rxdate[2]==0x03)
              {
                if(uart2.Rxdate[3]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=1;//1地址错误
                }
                else if(uart2.Rxdate[3]+uart2.Rxdate[5]>=FLASH_DATA_LENGHT)  //地址异常，如果写到其他地方就程序错乱了
                {
                  uart2_ERR_n=2;//1地址错误2初始地址加数据长度超范围
                }                
                else
                {
                  temp=uart2.Rxdate[3]-0x00;

                  for(i=0;i<uart2.Rxdate[5];i++)
                  {
                    
                    u32RTU_C_REG[temp+i]=(u16)uart2.Rxdate[7+i*2]<<8;
                    u32RTU_C_REG[temp+i]+=(u16)uart2.Rxdate[7+i*2+1];
                    
                  } 
                }               
              } 
              else  //地址错误              
              {
                uart2_ERR_n=1;
              }              
              
//=======================通信地址错误处理==========================                
              uart2_adress_error(uart2_ERR_n);//返回地址错误                  
              
       
            break;
          }

        default:

          break;
      }       

    }
    
    else if(data_485_Y_N==2 )//json数据
    {
//      u8 data_ok;

      JSON_GetObjectItem();//解析接受到的正确的json包并更新系统参数 0异常1正常 

      return ;  // 不需要应答    
    }
    else
    {
      uart2.RxCounterdata_filish=0;        
    }
  }

}



void USART2Send_Handler( void )  
{

//====================处理数据 ===========================================

  
//  u8 *cmd_ptr;//命令指针变量 
  u16 i;

    uart2.Tx_gap_time=20;

    if(uart2.Tx_gap_cnt<uart2.Tx_gap_time)//发送完上个数据包后间隔20ms期间也没有接受到通信数据
    {
      return;  
    }      
    uart2.Tx_gap_cnt=0;
  


    if(uart2.Tx1_enable==1)
    {
      uart2.Tx1_enable=0;
      
  
      if(uart2.Tx_standard==0)   //要发送的数据是否为标志协议，0 485数据,1json数据   
      {
        switch( uart2.TxBuffer[1] )                        //
        {  
      
          case 0x03:  //读
            {   
              uart2_Send_string( uart2.TxBuffer[2]+5 );   //发送数据长度 7      
              break;
            }
            
          case 0x04:      //读
            {
              uart2_Send_string( uart2.TxBuffer[2]+5 );   //发送数据长度 7      
              break;
            }
          case 0x06:      //写     
            {
              uart2_Send_string( 8 );   //发送数据长度 8      
              break;
            }          
          case 0x10:      //写 
            {
              uart2_Send_string( 8 );   //发送数据长度 8      
              break;
            }

          default:

            break;
        }       
                
        
      }
      else if(uart2.Tx_standard==1)   //要发送的数据是否为标志协议，0 485数据,1json数据   
      { 
        uart2.TxBufferSize= strlen(jsonBuffer_create);//uart2.RxBuffer); 

        for (i=0;i<uart2.TxBufferSize || i<500 ;i++) 
        {
          uart2.TxBuffer[i]=jsonBuffer_create[i];
        }

        uart2_Send_string( uart2.TxBufferSize);   //发送json数据         
      }
      
      else if(uart2.Tx_standard==2)   //要发送的数据是否为标志协议，0 485数据,1json数据   
      { 
        uart2.TxBufferSize= strlen(jsonBuffer_create);//uart2.RxBuffer); 

        for (i=0;i<uart2.TxBufferSize || i<500 ;i++) 
        {
          uart2.TxBuffer[i]=jsonBuffer_create[i];
        }

        uart2_Send_string( uart2.TxBufferSize);   //发送json数据         
      }      
      
    }



}


void uart2_1ms( void ) //每1ms进一次，在1ms中断里面引用  
{
      uart2.uart_ms_cnt++;        //UART2_LINK( void )时间窗
      uart2.Tx_gap_cnt++;         //发送完上个数据包后间隔20ms期间也没有接受到通信数据   
      uart2.err_delay_cnt++;     
     
      if ( uart2.err_delay_cnt >20 )//从接受完1个字节开始计时20ms没收到数据判断已接收完一个数据包
      {
        uart2.err_delay_cnt=21;        
      }    
      else if(uart2.err_delay_cnt==20)
      {
        UART2Receive();    //处理接受到的数据包，先判断数据包是否正确
        UART2Receive_res();//接收错误复位
      }   
}



void uart2_Send_string( u16 length )   //启动发送数据
{
  uart2.Txing_status=1;//是否已经发送完0发完1正在发   
  uart2.TxBufferSize=length;   //数据长度    
  uart2.Txindex=0;    
  USART_ClearFlag(USART2,USART_FLAG_TXE); //一定要清除发送中断标志 
  USART_ITConfig(USART2, USART_IT_TXE, ENABLE);  //打开发送中断，这句是关键    
}


void UART2_LINK( void )//可以放在主程序里面
{
  if ( uart2.uart_ms_cnt<1 )//1ms
  {    
    return;   
  }
  uart2.uart_ms_cnt=0;
  

  UART2Handler ();  
  
  USART2Send_Handler();
  
  USART2_modbus_ONOFF();// modbus退出计数器 在程序里限制在1min退出
  
} 


